package com.itheima.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.itheima.dao.CheckGroupDao;
import com.itheima.entity.PageResult;
import com.itheima.entity.QueryPageBean;
import com.itheima.pojo.CheckGroup;
import com.itheima.service.CheckGroupService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service(interfaceClass = CheckGroupService.class)  //代理对象向外暴露的类型
@Transactional
public class CheckGroupServiceImpl implements CheckGroupService {

    @Autowired
    private CheckGroupDao checkGroupDao;

    @Override
    public void addCheckGroup(CheckGroup checkGroup, Integer[] checkitemIds) {
        //添加检查组：
        //第一步：先添加检查组,应返回此检查组对象的id值
        checkGroupDao.addCheckGroup(checkGroup);
        //得到此检查组对象的id值
        Integer checkGroupId = checkGroup.getId();
        //第二步：往中间表中添加此检查组包含的检查项
        /*
        * 此时添加需要传入的检查组的id和检查项id的数组，
        * 传入多个参数，将其封装到map集合中
        * 将此方法封装起来
        * */
        addCheckGroupAndCheckItem(checkGroupId,checkitemIds);

    }

    @Override
    public PageResult findByCondition(QueryPageBean queryPageBean) {

        //取出QueryPageBean的数据
        Integer currentPage = queryPageBean.getCurrentPage();
        Integer pageSize = queryPageBean.getPageSize();
        String queryString = queryPageBean.getQueryString();

        //使用pageHelper插件分页
        PageHelper.startPage(currentPage,pageSize);

        Page<CheckGroup> list = checkGroupDao.findByCondition(queryString);
        long total = list.getTotal();
        List<CheckGroup> result = list.getResult();

        return new PageResult(total,result);
    }

    @Override
    public CheckGroup findCheckGroup(Integer id) {
        return checkGroupDao.findById(id);
    }

    @Override
    public List<Integer> findCheckItemIds(Integer id) {
        return checkGroupDao.findCheckItemIds(id);
    }

    @Override
    public void updateCheckGroup(CheckGroup checkGroup, Integer[] checkitemIds) {
        //更新此检查组的信息
        //1.先更新此检查组的基本信息(检查组表t_checkgroup)
        checkGroupDao.update(checkGroup);
        //2.更新此检查组和检查项的映射关系(中间表t_checkgroup_checkiteam)
        //第一种想法：先删除此检查项之前与检查项的对应关系，然后再重新添加
        Integer checkGroupId = checkGroup.getId();
        checkGroupDao.delCheckGroupAndCheckItems(checkGroupId);
        //调用封装的方法添加对应关系
        addCheckGroupAndCheckItem(checkGroupId,checkitemIds);
        //第二种想法：比对更新前后的对应关系，checkitemIds，去除公共部分，得到要删除和添加的部分
        /*List<Integer> oldCheckItemIds = checkGroupDao.findCheckItemIds(checkGroupId);

        List<Integer> newCheckItemIds = Arrays.asList(checkitemIds);

        //需要删除的检查项的id(即旧的减去公共的),但是此时时list集合需要转成数组，不能直接转
        Integer[] delCheckItemIds = delCommon(oldCheckItemIds,newCheckItemIds);

        System.out.println("============================="+delCheckItemIds);

        delCheckGroupAndCheckItem(checkGroupId,delCheckItemIds);
        //需要插入的检查项的id(即新的减去公共的)
        Integer[] addCheckItemIds = delCommon(newCheckItemIds,oldCheckItemIds);

        System.out.println("============================="+addCheckItemIds);
        addCheckGroupAndCheckItem(checkGroupId,addCheckItemIds);*/
    }

    @Override
    public List<CheckGroup> findAll() {
        return checkGroupDao.findAll();
    }

    //抽取方法，用于删除两个list集合的公共元素
    public Integer[] delCommon(List<Integer> list,List<Integer> baseList){
        //(因为要按照元素值删除元素，而list集合会将传入的值作为索引来使用)
        HashSet<Integer> set = new HashSet<Integer>(list);
        HashSet<Integer> baseSet = new HashSet<Integer>(baseList);
        for (Object obj : baseSet) {
            //以前的集合删除更新的集合(只会删除公共元素)
            set.remove(obj);
        }

        List<Integer> resultList = new ArrayList<Integer>(set);
        Integer[] arr = new Integer[resultList.size()];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = resultList.get(i);
        }

        return arr;
    }

    //抽取方法，用于插入检查组和检查项的对应关系
    public void addCheckGroupAndCheckItem(Integer checkGroupId,Integer[] checkItemIds){
        //添加检查组和检查项的对应关系(每次插入一个数据)
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("checkgroup_id",checkGroupId);
        if (checkItemIds!=null && checkItemIds.length>0){
            for (Integer checkitemId : checkItemIds) {
                map.put("checkitem_id",checkitemId);
                checkGroupDao.addCheckGroupAndCheckItem(map);
            }
        }

    }

    //抽取方法，用于删除检查组和检查项的对应关系
    public void delCheckGroupAndCheckItem(Integer checkGroupId,Integer[] checkItemIds){
        //添加检查组和检查项的对应关系(每次插入一个数据)
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("checkgroup_id",checkGroupId);
        if (checkItemIds!=null && checkItemIds.length>0){
            for (Integer checkitemId : checkItemIds) {
                map.put("checkitem_id",checkitemId);
                checkGroupDao.delCheckGroupAndCheckItem(map);
            }
        }

    }
}
